home *** CD-ROM | disk | FTP | other *** search
/ Visual Cafe 3 / Visual Cafe 3.ISO / Vcafe / Source.bin / MultiListBeanInfo.java < prev    next >
Text File  |  1998-08-21  |  22KB  |  569 lines
  1. package symantec.itools.awt;
  2.  
  3. import java.beans.*;
  4. import symantec.itools.beans.*;
  5. import java.util.ResourceBundle;
  6.  
  7. //     07/14/97    LAB    Added allowSorting property and connections.
  8. //  07/29/97    CAR corrected typo in allowSorting property descriptor section
  9. //  08/07/97    RKM Removed color from property names
  10. //                    Changed BackGround/ForeGround to Background & Foreground respectively
  11. //  08/10/97    RKM Corrected allowSorting and multiMode to use custom getter and setter
  12. //  08/14/97    CAR commented out method descriptor for getColumnSize
  13. //    09/19/97    RKM    Fixed Toggle Allow Sorting connection
  14. //                    Removed 08/10/97 "fix" - it wasn't a problem
  15. //                    Fixed Set Allow Sorting connection
  16. //                    Added setShortDescription for List Items
  17. //  08/19/98    LAB    Moved to GroupAWTAdditions folder.
  18.  
  19. /**
  20.  * BeanInfo for MultiList.
  21.  *
  22.  */
  23.  
  24. public class MultiListBeanInfo extends SimpleBeanInfo {
  25.  
  26.     /**
  27.      * Constructs a MultiListBeanInfo object.
  28.      */
  29.     public MultiListBeanInfo() {
  30.     }
  31.  
  32.     /**
  33.      * Gets a BeanInfo for the superclass of this bean.
  34.      * @return BeanInfo[] containing this bean's superclass BeanInfo
  35.      */
  36.     public BeanInfo[] getAdditionalBeanInfo() {
  37.         try {
  38.             BeanInfo[] bi = new BeanInfo[1];
  39.             bi[0] = Introspector.getBeanInfo(beanClass.getSuperclass());
  40.             return bi;
  41.         }
  42.         catch (IntrospectionException e) { throw new Error(e.toString());}
  43.     }
  44.  
  45.     /**
  46.      * Gets the SymantecBeanDescriptor for this bean.
  47.      * @return an object of type SymantecBeanDescriptor
  48.      * @see symantec.itools.beans.SymantecBeanDescriptor
  49.      */
  50.     public BeanDescriptor getBeanDescriptor() {
  51.         ResourceBundle group = ResourceBundle.getBundle("symantec.itools.resources.GroupBundle");
  52.         String s=group.getString("GroupAWTAdditions"); 
  53.  
  54.         SymantecBeanDescriptor bd = new SymantecBeanDescriptor(beanClass);
  55.         bd.setCanAddChild(false);
  56.         bd.setWinHelp("0x12393");
  57.         bd.setFolder(s);
  58.  
  59.         return (BeanDescriptor) bd;
  60.     }
  61.  
  62.     /**
  63.      * Gets an image that may be used to visually represent this bean
  64.      * (in the toolbar, on a form, etc).
  65.      * @param iconKind the type of icon desired, one of: BeanInfo.ICON_MONO_16x16,
  66.      * BeanInfo.ICON_COLOR_16x16, BeanInfo.ICON_MONO_32x32, or BeanInfo.ICON_COLOR_32x32.
  67.      * @return an image for this bean, always color even if requested monochrome
  68.      * @see BeanInfo#ICON_MONO_16x16
  69.      * @see BeanInfo#ICON_COLOR_16x16
  70.      * @see BeanInfo#ICON_MONO_32x32
  71.      * @see BeanInfo#ICON_COLOR_32x32
  72.      */
  73.     public java.awt.Image getIcon(int iconKind) {
  74.         if (iconKind == BeanInfo.ICON_MONO_16x16 ||
  75.             iconKind == BeanInfo.ICON_COLOR_16x16) {
  76.             java.awt.Image img = loadImage("MultiListC16.gif");
  77.             return img;
  78.         }
  79.  
  80.         if (iconKind == BeanInfo.ICON_MONO_32x32 ||
  81.             iconKind == BeanInfo.ICON_COLOR_32x32) {
  82.             java.awt.Image img = loadImage("MultiListC32.gif");
  83.             return img;
  84.         }
  85.  
  86.         return null;
  87.     }
  88.  
  89.     /**
  90.      * Gets an array of descriptions of the methods used for "connections" by
  91.      * Visual CafΘ's Interaction Wizard.
  92.      * Included in each method description is a CONNECTIONS ConnectionDescriptor.
  93.      * @return method descriptions for this bean
  94.      * @see symantec.itools.beans.ConnectionDescriptor#CONNECTIONS
  95.      */
  96.     public MethodDescriptor[] getMethodDescriptors() {
  97.         Class[] args;
  98.         ConnectionDescriptor connection;
  99.         java.util.Vector connections;
  100.         java.util.Vector md = new java.util.Vector();
  101.         ResourceBundle conn = ResourceBundle.getBundle("symantec.itools.resources.ConnBundle");
  102.  
  103.         try{
  104.             args = new Class[1];
  105.             args[0] = java.awt.Color.class ;
  106.             MethodDescriptor setHeadingBg = new MethodDescriptor(beanClass.getMethod("setHeadingBg", args));
  107.  
  108.             connections = new java.util.Vector();
  109.             connection = new ConnectionDescriptor("input", "Color", "",
  110.                                     "%name%.setHeadingBg(%arg%);",
  111.                                     conn.getString("setHeadingBg"));
  112.             connections.addElement(connection);
  113.  
  114.             setHeadingBg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  115.             md.addElement(setHeadingBg);
  116.         } catch (Exception e) { throw new Error("setHeadingBg:: " + e.toString()); }
  117.  
  118.         try{
  119.             args = new Class[2];
  120.             args[0] = java.lang.Integer.TYPE ;
  121.             args[1] = java.lang.Integer.TYPE ;
  122.             MethodDescriptor setColumnAlignment = new MethodDescriptor(beanClass.getMethod("setColumnAlignment", args));
  123.  
  124.             connections = new java.util.Vector();
  125.             connection = new ConnectionDescriptor("input", "int", "",
  126.                                     "%name%.setColumnAlignment(%arg%, %name%.LEFT);",
  127.                                     conn.getString("setColumnAlignmentLeft"));
  128.             connections.addElement(connection);
  129.  
  130.             connection = new ConnectionDescriptor("input", "int", "",
  131.                                     "%name%.setColumnAlignment(%arg%, %name%.CENTER);",
  132.                                     conn.getString("setColumnAlignmentCenter"));
  133.             connections.addElement(connection);
  134.  
  135.             connection = new ConnectionDescriptor("input", "int", "",
  136.                                     "%name%.setColumnAlignment(%arg%, %name%.RIGHT);",
  137.                                     conn.getString("setColumnAlignmentRight"));
  138.             connections.addElement(connection);
  139.  
  140.             setColumnAlignment.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  141.             md.addElement(setColumnAlignment);
  142.         } catch (Exception e) { throw new Error("setColumnAlignment:: " + e.toString()); }
  143.  
  144.         try{
  145.             args = new Class[1];
  146.             args[0] = java.awt.Color.class ;
  147.             MethodDescriptor setCellFg = new MethodDescriptor(beanClass.getMethod("setCellFg", args));
  148.  
  149.             connections = new java.util.Vector();
  150.             connection = new ConnectionDescriptor("input", "Color", "",
  151.                                     "%name%.setCellFg(%arg%);",
  152.                                     conn.getString("setCellFg"));
  153.             connections.addElement(connection);
  154.  
  155.             setCellFg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  156.             md.addElement(setCellFg);
  157.         } catch (Exception e) { throw new Error("setCellFg:: " + e.toString()); }
  158.  
  159.         try{
  160.             args = null;
  161.             MethodDescriptor getCellFont = new MethodDescriptor(beanClass.getMethod("getCellFont", args));
  162.  
  163.             connections = new java.util.Vector();
  164.             connection = new ConnectionDescriptor("output", "Font", "",
  165.                                     "%name%.getCellFont()",
  166.                                     conn.getString("getCellFont"));
  167.             connections.addElement(connection);
  168.  
  169.             getCellFont.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  170.             md.addElement(getCellFont);
  171.         } catch (Exception e) { throw new Error("getCellFont:: " + e.toString()); }
  172.  
  173.         try{
  174.             args = new Class[1];
  175.             args[0] = java.awt.Font.class ;
  176.             MethodDescriptor setCellFont = new MethodDescriptor(beanClass.getMethod("setCellFont", args));
  177.  
  178.             connections = new java.util.Vector();
  179.             connection = new ConnectionDescriptor("input", "Font", "",
  180.                                     "%name%.setCellFont(%arg%);",
  181.                                     conn.getString("setCellFont"));
  182.             connections.addElement(connection);
  183.  
  184.             setCellFont.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  185.             md.addElement(setCellFont);
  186.         } catch (Exception e) { throw new Error("setCellFont:: " + e.toString()); }
  187.  
  188.         try{
  189.             args = new Class[1];
  190.             args[0] = java.lang.Integer.TYPE ;
  191.             MethodDescriptor setNumberOfCols = new MethodDescriptor(beanClass.getMethod("setNumberOfCols", args));
  192.  
  193.             connections = new java.util.Vector();
  194.             connection = new ConnectionDescriptor("input", "int", "",
  195.                                     "%name%.setNumberOfCols(%arg%);",
  196.                                     conn.getString("setNumberOfCols"));
  197.             connections.addElement(connection);
  198.  
  199.             setNumberOfCols.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  200.             md.addElement(setNumberOfCols);
  201.         } catch (Exception e) { throw new Error("setNumberOfCols:: " + e.toString()); }
  202.  
  203.         try{
  204.             args = null;
  205.             MethodDescriptor getHeadingFg = new MethodDescriptor(beanClass.getMethod("getHeadingFg", args));
  206.  
  207.             connections = new java.util.Vector();
  208.             connection = new ConnectionDescriptor("output", "Color", "",
  209.                                     "%name%.getHeadingFg()",
  210.                                     conn.getString("getHeadingFg"));
  211.             connections.addElement(connection);
  212.  
  213.             getHeadingFg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  214.             md.addElement(getHeadingFg);
  215.         } catch (Exception e) { throw new Error("getHeadingFg:: " + e.toString()); }
  216.  
  217.         try{
  218.             args = null;
  219.             MethodDescriptor getCellBg = new MethodDescriptor(beanClass.getMethod("getCellBg", args));
  220.  
  221.             connections = new java.util.Vector();
  222.             connection = new ConnectionDescriptor("output", "Color", "",
  223.                                     "%name%.getCellBg()",
  224.                                     conn.getString("getCellBg"));
  225.             connections.addElement(connection);
  226.  
  227.             getCellBg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  228.             md.addElement(getCellBg);
  229.         } catch (Exception e) { throw new Error("getCellBg:: " + e.toString()); }
  230.  
  231.         try{
  232.             args = null;
  233.             MethodDescriptor getHeadingFont = new MethodDescriptor(beanClass.getMethod("getHeadingFont", args));
  234.  
  235.             connections = new java.util.Vector();
  236.             connection = new ConnectionDescriptor("output", "Font", "",
  237.                                     "%name%.getHeadingFont()",
  238.                                     conn.getString("getHeadingFont"));
  239.             connections.addElement(connection);
  240.  
  241.             getHeadingFont.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  242.             md.addElement(getHeadingFont);
  243.         } catch (Exception e) { throw new Error("getHeadingFont:: " + e.toString()); }
  244.  
  245.         try{
  246.             args = new Class[1];
  247.             args[0] = java.awt.Color.class ;
  248.             MethodDescriptor setCellBg = new MethodDescriptor(beanClass.getMethod("setCellBg", args));
  249.  
  250.             connections = new java.util.Vector();
  251.             connection = new ConnectionDescriptor("input", "Color", "",
  252.                                     "%name%.setCellBg(%arg%);",
  253.                                     conn.getString("setCellBg"));
  254.             connections.addElement(connection);
  255.  
  256.             setCellBg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  257.             md.addElement(setCellBg);
  258.         } catch (Exception e) { throw new Error("setCellBg:: " + e.toString()); }
  259.  
  260.         try{
  261.             args = new Class[1];
  262.             args[0] = java.awt.Color.class ;
  263.             MethodDescriptor setHeadingFg = new MethodDescriptor(beanClass.getMethod("setHeadingFg", args));
  264.  
  265.             connections = new java.util.Vector();
  266.             connection = new ConnectionDescriptor("input", "Color", "",
  267.                                     "%name%.setHeadingFg(%arg%);",
  268.                                     conn.getString("setHeadingFg"));
  269.             connections.addElement(connection);
  270.  
  271.             setHeadingFg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  272.             md.addElement(setHeadingFg);
  273.         } catch (Exception e) { throw new Error("setHeadingFg:: " + e.toString()); }
  274.  
  275.         try{
  276.             args = new Class[1];
  277.             args[0] = java.awt.Font.class ;
  278.             MethodDescriptor setHeadingFont = new MethodDescriptor(beanClass.getMethod("setHeadingFont", args));
  279.  
  280.             connections = new java.util.Vector();
  281.             connection = new ConnectionDescriptor("input", "Font", "",
  282.                                     "%name%.setHeadingFont(%arg%);",
  283.                                     conn.getString("setHeadingFont"));
  284.             connections.addElement(connection);
  285.  
  286.             setHeadingFont.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  287.             md.addElement(setHeadingFont);
  288.         } catch (Exception e) { throw new Error("setHeadingFont:: " + e.toString()); }
  289.  
  290.         try{
  291.             args = null;
  292.             MethodDescriptor getNumberOfCols = new MethodDescriptor(beanClass.getMethod("getNumberOfCols", args));
  293.  
  294.             connections = new java.util.Vector();
  295.             connection = new ConnectionDescriptor("output", "int", "",
  296.                                     "%name%.getNumberOfCols()",
  297.                                     conn.getString("getNumberOfCols"));
  298.             connections.addElement(connection);
  299.  
  300.             getNumberOfCols.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  301.             md.addElement(getNumberOfCols);
  302.         } catch (Exception e) { throw new Error("getNumberOfCols:: " + e.toString()); }
  303.  
  304.         /*
  305.         try{
  306.             args = new Class[1];
  307.             args[0] = java.lang.Integer.TYPE ;
  308.             MethodDescriptor getColumnSize = new MethodDescriptor(beanClass.getMethod("getColumnSize", args));
  309.  
  310.             connections = new java.util.Vector();
  311.             connection = new ConnectionDescriptor("output", "int", "",
  312.                                     "%name%.getColumnSize(%arg%)",
  313.                                     conn.getString("getColumnSize"));
  314.             connections.addElement(connection);
  315.  
  316.             getColumnSize.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  317.             md.addElement(getColumnSize);
  318.         } catch (Exception e) { throw new Error("getColumnSize:: " + e.toString()); }
  319.         */
  320.  
  321.         try{
  322.             args = null;
  323.             MethodDescriptor getHeadingBg = new MethodDescriptor(beanClass.getMethod("getHeadingBg", args));
  324.  
  325.             connections = new java.util.Vector();
  326.             connection = new ConnectionDescriptor("output", "Color", "",
  327.                                     "%name%.getHeadingBg()",
  328.                                     conn.getString("getHeadingBg"));
  329.             connections.addElement(connection);
  330.  
  331.             getHeadingBg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  332.             md.addElement(getHeadingBg);
  333.         } catch (Exception e) { throw new Error("getHeadingBg:: " + e.toString()); }
  334.  
  335.         try{
  336.             args = null;
  337.             MethodDescriptor clear = new MethodDescriptor(beanClass.getMethod("clear", args));
  338.  
  339.             connections = new java.util.Vector();
  340.             connection = new ConnectionDescriptor("input", "void", "",
  341.                                     "%name%.clear();",
  342.                                     conn.getString("clearMList"));
  343.             connections.addElement(connection);
  344.  
  345.             clear.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  346.             md.addElement(clear);
  347.         } catch (Exception e) { throw new Error("clear:: " + e.toString()); }
  348.  
  349.         try{
  350.             args = null;
  351.             MethodDescriptor getSelectedRow = new MethodDescriptor(beanClass.getMethod("getSelectedRow", args));
  352.  
  353.             connections = new java.util.Vector();
  354.             connection = new ConnectionDescriptor("output", "int", "",
  355.                                     "%name%.getSelectedRow()",
  356.                                     conn.getString("getSelectedRow"));
  357.             connections.addElement(connection);
  358.  
  359.             getSelectedRow.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  360.             md.addElement(getSelectedRow);
  361.         } catch (Exception e) { throw new Error("getSelectedRow:: " + e.toString()); }
  362.  
  363.         try{
  364.             args = null;
  365.             MethodDescriptor getCellFg = new MethodDescriptor(beanClass.getMethod("getCellFg", args));
  366.  
  367.             connections = new java.util.Vector();
  368.             connection = new ConnectionDescriptor("output", "Color", "",
  369.                                     "%name%.getCellFg()",
  370.                                     conn.getString("getCellFg"));
  371.             connections.addElement(connection);
  372.  
  373.             getCellFg.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  374.             md.addElement(getCellFg);
  375.         } catch (Exception e) { throw new Error("getCellFg:: " + e.toString()); }
  376.  
  377.         try{
  378.             args = new Class[1];
  379.             args[0] = java.lang.Integer.TYPE ;
  380.             MethodDescriptor createColumns = new MethodDescriptor(beanClass.getMethod("createColumns", args));
  381.  
  382.             connections = new java.util.Vector();
  383.             connection = new ConnectionDescriptor("input", "int", "",
  384.                                     "%name%.createColumns(%arg%);",
  385.                                     conn.getString("createColumns"));
  386.             connections.addElement(connection);
  387.  
  388.             createColumns.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  389.             md.addElement(createColumns);
  390.         } catch (Exception e) { throw new Error("createColumns:: " + e.toString()); }
  391.  
  392.         try{
  393.             args = new Class[1];
  394.             args[0] = java.lang.Integer.TYPE ;
  395.             MethodDescriptor setSelectedRow = new MethodDescriptor(beanClass.getMethod("setSelectedRow", args));
  396.  
  397.             connections = new java.util.Vector();
  398.             connection = new ConnectionDescriptor("input", "int", "",
  399.                                     "%name%.setSelectedRow(%arg%);",
  400.                                     conn.getString("setSelectedRow"));
  401.             connections.addElement(connection);
  402.  
  403.             setSelectedRow.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  404.             md.addElement(setSelectedRow);
  405.         } catch (Exception e) { throw new Error("setSelectedRow:: " + e.toString()); }
  406.  
  407.         try{
  408.             args = new Class[1];
  409.             args[0] = java.lang.Boolean.TYPE ;
  410.             MethodDescriptor setAllowSorting = new MethodDescriptor(beanClass.getMethod("setAllowSorting", args));
  411.  
  412.             connections = new java.util.Vector();
  413.             connection = new ConnectionDescriptor("input", "void", "",
  414.                                     "%name%.setAllowSorting(!%name%.isAllowSorting());",
  415.                                     conn.getString("setAllowSortingToggle"));
  416.             connections.addElement(connection);
  417.             connection = new ConnectionDescriptor("input", "boolean", "",
  418.                                     "%name%.setAllowSorting(%arg%);",
  419.                                     conn.getString("setAllowSortingValue"));
  420.             connections.addElement(connection);
  421.  
  422.             setAllowSorting.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  423.             md.addElement(setAllowSorting);
  424.         } catch (Exception e) { throw new Error("setAllowSorting:: " + e.toString()); }
  425.  
  426.         try{
  427.             args = null;
  428.             MethodDescriptor isAllowSorting = new MethodDescriptor(beanClass.getMethod("isAllowSorting", args));
  429.  
  430.             connections = new java.util.Vector();
  431.             connection = new ConnectionDescriptor("output", "boolean", "",
  432.                                     "%name%.isAllowSorting()",
  433.                                     conn.getString("isAllowSorting"));
  434.             connections.addElement(connection);
  435.             connection = new ConnectionDescriptor("output", "boolean", "",
  436.                                     "!%name%.isAllowSorting()",
  437.                                     conn.getString("isNotAllowSorting"));
  438.             connections.addElement(connection);
  439.  
  440.             isAllowSorting.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  441.             md.addElement(isAllowSorting);
  442.         } catch (Exception e) { throw new Error("isAllowSorting:: " + e.toString()); }
  443.  
  444.         try{
  445.             args = null;
  446.             MethodDescriptor selectAll = new MethodDescriptor(beanClass.getMethod("selectAll", args));
  447.  
  448.             connections = new java.util.Vector();
  449.             connection = new ConnectionDescriptor("input", "void", "",
  450.                                     "%name%.selectAll();",
  451.                                     conn.getString("selectAllMList"));
  452.             connections.addElement(connection);
  453.  
  454.             selectAll.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  455.             md.addElement(selectAll);
  456.         } catch (Exception e) { throw new Error("selectAll:: " + e.toString()); }
  457.  
  458.         try{
  459.             args = null;
  460.             MethodDescriptor deselectAll = new MethodDescriptor(beanClass.getMethod("deselectAll", args));
  461.  
  462.             connections = new java.util.Vector();
  463.             connection = new ConnectionDescriptor("input", "void", "",
  464.                                     "%name%.deselectAll();",
  465.                                     conn.getString("deselectAllMList"));
  466.             connections.addElement(connection);
  467.  
  468.             deselectAll.setValue(ConnectionDescriptor.CONNECTIONS, connections);
  469.             md.addElement(deselectAll);
  470.         } catch (Exception e) { throw new Error("deselectAll:: " + e.toString()); }
  471.  
  472.         MethodDescriptor[] rv = new MethodDescriptor[md.size()];
  473.         md.copyInto(rv);
  474.  
  475.         return rv;
  476.     }
  477.  
  478.     /**
  479.      * Returns descriptions of this bean's properties.
  480.      */
  481.     public PropertyDescriptor[] getPropertyDescriptors() {
  482.         ResourceBundle prop = ResourceBundle.getBundle("symantec.itools.resources.PropBundle");
  483.  
  484.         try{
  485.         PropertyDescriptor cellFont = new PropertyDescriptor("cellFont", beanClass);
  486.         cellFont.setBound(true);
  487.         cellFont.setConstrained(true);
  488.         cellFont.setDisplayName(prop.getString("cellFont"));
  489.  
  490.         PropertyDescriptor cellBg = new PropertyDescriptor("cellBg", beanClass);
  491.         cellBg.setBound(true);
  492.         cellBg.setConstrained(true);
  493.         cellBg.setDisplayName(prop.getString("cellBg"));
  494.  
  495.         PropertyDescriptor cellFg = new PropertyDescriptor("cellFg", beanClass);
  496.         cellFg.setBound(true);
  497.         cellFg.setConstrained(true);
  498.         cellFg.setDisplayName(prop.getString("cellFg"));
  499.  
  500.         PropertyDescriptor headingBg = new PropertyDescriptor("headingBg", beanClass);
  501.         headingBg.setBound(true);
  502.         headingBg.setConstrained(true);
  503.         headingBg.setDisplayName(prop.getString("headingBg"));
  504.  
  505.         PropertyDescriptor headingFg = new PropertyDescriptor("headingFg", beanClass);
  506.         headingFg.setBound(true);
  507.         headingFg.setConstrained(true);
  508.         headingFg.setDisplayName(prop.getString("headingFg"));
  509.  
  510.         PropertyDescriptor headingFont = new PropertyDescriptor("headingFont", beanClass);
  511.         headingFont.setBound(true);
  512.         headingFont.setConstrained(true);
  513.         headingFont.setDisplayName(prop.getString("headingFont"));
  514.  
  515.         PropertyDescriptor headings = new PropertyDescriptor("headings", beanClass);
  516.         headings.setBound(true);
  517.         headings.setConstrained(true);
  518.         headings.setDisplayName(prop.getString("headings"));
  519.  
  520.         PropertyDescriptor listItems = new PropertyDescriptor("listItems", beanClass);
  521.         listItems.setBound(true);
  522.         listItems.setConstrained(true);
  523.         listItems.setDisplayName(prop.getString("listItems"));
  524.         listItems.setShortDescription(prop.getString("multiListSDescription"));
  525.  
  526.         PropertyDescriptor columnSizes = new PropertyDescriptor("columnSizes", beanClass);
  527.         columnSizes.setBound(true);
  528.         columnSizes.setConstrained(true);
  529.         columnSizes.setDisplayName(prop.getString("columnSizes"));
  530.  
  531.         PropertyDescriptor columnAlignments = new PropertyDescriptor("columnAlignments", beanClass);
  532.         columnAlignments.setBound(true);
  533.         columnAlignments.setConstrained(true);
  534.         columnAlignments.setDisplayName(prop.getString("columnAlignments"));
  535.  
  536.         PropertyDescriptor allowSorting = new PropertyDescriptor("allowSorting", beanClass);
  537.         allowSorting.setBound(true);
  538.         allowSorting.setConstrained(true);
  539.         allowSorting.setDisplayName(prop.getString("allowSorting"));
  540.  
  541.         PropertyDescriptor multipleMode = new PropertyDescriptor("multipleMode", beanClass);
  542.         multipleMode.setBound(true);
  543.         multipleMode.setConstrained(true);
  544.         multipleMode.setDisplayName(prop.getString("multipleMode"));
  545.  
  546.         PropertyDescriptor layout = new PropertyDescriptor("layout", beanClass);
  547.         layout.setHidden(true);
  548.  
  549.         PropertyDescriptor[] rv = {
  550.             cellFont,
  551.             cellBg,
  552.             cellFg,
  553.             headingBg,
  554.             headingFg,
  555.             headingFont,
  556.             headings,
  557.             listItems,
  558.             columnSizes,
  559.             columnAlignments,
  560.             allowSorting,
  561.             multipleMode,
  562.             layout};
  563.         return rv;
  564.         } catch (IntrospectionException e) { throw new Error(e.toString()); }
  565.     }
  566.  
  567.     private final static Class beanClass = MultiList.class;
  568.  
  569.     }    //  end of class MultiListBeanInfo